home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 February / Gamestar_81_2006-02_dvd.iso / Red Shark / Missions / Mission_2 / MissionTasks.script < prev    next >
Text File  |  2001-12-24  |  17KB  |  788 lines
  1. //-------------------------------------------------------------------
  2. //
  3. //  This code is copyright 2001 by G5 Software.
  4. //  Any unauthorized usage, either in part or in whole of this code
  5. //  is strictly prohibited. Violators WILL be prosecuted to the
  6. //  maximum extent allowed by law.
  7. //
  8. //-------------------------------------------------------------------
  9.  
  10. ///////////////////////////////////
  11. //
  12. // Mission 2. "Convoy"
  13. //
  14. //
  15.  
  16.  
  17. //
  18. // *** mission AI controller ***
  19. //
  20.  
  21. class CConvoyMission_AIController extends CBaseAIController
  22. {
  23.   boolean PlatoonAIsAttacks = false;
  24.   boolean PlatoonBIsAttacks = false;
  25.  
  26.   boolean PlatoonAIsMoving = false;
  27.   boolean PlatoonBIsMoving = false;
  28.  
  29.   void OnObjectEnterArea( int _NavPointIndex, string _NavPointName, string _ObjectID)
  30.   {
  31.     if ( _NavPointName == "NavPoint_Destination"
  32.       && Core_IsStringStartsWith( _ObjectID, "SovietTruck_Transport"))
  33.     {
  34.       // Mission accomplished
  35.       Core_BroadcastEvent("OnTransportsEnteredDestinationZone");
  36.     };
  37.  
  38.     if ( _NavPointName == "NavPoint_Ambush_1"
  39.       && ( Core_IsStringStartsWith( _ObjectID, "SovietTruck_Transport")))
  40.       //|| Core_IsStringStartsWith( _ObjectID, "Helicopter") ) )
  41.     {
  42.       // Convoy entered ambush 1 back attack zone
  43.       /*
  44.       Core_SendEventTo(
  45.         "NaziTank_Ambusher_1 1",
  46.         "OnAttackConvoy");
  47.       Core_SendEventTo(
  48.         "NaziTank_Ambusher_1 2",
  49.         "OnAttackConvoy");
  50.         */
  51.  
  52.       Core_BroadcastEvent( "OnAttackConvoy_1");
  53.     }
  54.  
  55.     if ( _NavPointName == "NavPoint_Ambush_2"
  56.       && Core_IsStringStartsWith( _ObjectID, "SovietTruck_Transport"))
  57.     {
  58.       // Convoy entered ambush 2 back attack zone
  59.       /*
  60.       Core_SendEventTo(
  61.         "NaziTank_Ambusher_2 1",
  62.         "OnAttackConvoy");
  63.       Core_SendEventTo(
  64.         "NaziTank_Ambusher_2 2",
  65.         "OnAttackConvoy");
  66.         */
  67.  
  68.       Core_BroadcastEvent( "OnAttackConvoy_2");
  69.     }
  70.  
  71.     if ( _NavPointName == "NavPoint_Ambush_1"
  72.       && Core_IsStringStartsWith( _ObjectID, "SovietTruck_Transport") && !PlatoonAIsMoving)
  73.     {
  74.       PlatoonAIsMoving = true;
  75.       Core_BroadcastEvent("Attack_A");
  76.     }
  77.  
  78.     if ( _NavPointName == "NavPoint_Ambush_2"
  79.       && Core_IsStringStartsWith( _ObjectID, "SovietTruck_Transport") && !PlatoonBIsMoving)
  80.     {
  81.       PlatoonBIsMoving = true;
  82.       Core_BroadcastEvent("Attack_B");
  83.     }
  84.     if ( _NavPointName == "NavPoint_PatrolA"
  85.       && Core_IsStringStartsWith( _ObjectID, "NaziTank_AttackA") && !PlatoonAIsAttacks)
  86.     {
  87.       PlatoonAIsAttacks = true;
  88.       Core_BroadcastEvent("AttackTarget_A");
  89.     }
  90.     if ( _NavPointName == "NavPoint_PatrolB"
  91.       && Core_IsStringStartsWith( _ObjectID, "NaziTank_AttackB") && !PlatoonBIsAttacks)
  92.     {
  93.       PlatoonBIsAttacks = true;
  94.       Core_BroadcastEvent("AttackTarget_B");
  95.     }
  96.   }
  97. }
  98.  
  99.  
  100. //
  101. // *** Autocade ***
  102. //
  103. // soviet transports convoy
  104.  
  105. class CConvoyMission_SovietTruck_ConvoyTransport extends CBaseAITask_BaseTask, CNavPointUser
  106. {
  107.   //
  108.   // convoy parameters
  109.  
  110.   vector   DestinationPoint        = GetNavPoint("NavPoint_Destination");//vector( 474 * 8, 1883 * 8, 0); // where to go
  111.   float    CruiserSpeed            = 22; // autocade with guard should keep this speed
  112.   float    RunSpeed                = 28; // autocade wo guards should keep this speed
  113.   float    OvertakeSpeed           = 34; // maximum allowed speed for overtake
  114.   float    AutocadDistanceMin      = 20; // nearest allowed distance in autocade
  115.   float    AutocadDistanceOptimum  = 25; // try to keep this distance in autocade
  116.   float    AutocadDistanceOvertake = 40; // overtake distance
  117.   float    DisperceRadius          = 50;
  118.   string   CurLeader               = "";
  119.   boolean  IsLeader                = false;
  120.  
  121.  
  122.   //
  123.   // current state
  124.  
  125.   boolean  Moving   = false; // true when object is moving to destination
  126.   boolean  Ambushed = false; // true when object is under ambush
  127.   boolean  Run      = false; // true when object is running without stop to destination
  128.  
  129.   void ClearState()
  130.   {
  131.     Moving    = false;
  132.     Ambushed  = false;
  133.     Run       = false;
  134.     CurLeader = "";
  135.     IsLeader  = false;
  136.   }
  137.  
  138.  
  139.   //
  140.   // start up initialization
  141.  
  142.   void Init()
  143.   {
  144.     // give start order
  145.     GiveOrder_MoveToTarget();
  146.   }
  147.  
  148.  
  149.   //
  150.   // orders
  151.  
  152.   void GiveOrder_MoveToTarget()
  153.   {
  154.     //Core_LogMessage("" + Core_GetIdentificator() + ": order: move to target");
  155.  
  156.     SetFireStyle_NoFire();
  157.  
  158.     string Leader = GetCommander("Convoy_Rank"); // find leader that we should followed by
  159.     if ( Moving == true
  160.       && Leader == CurLeader)
  161.     {
  162.       // nothing changed
  163.       return;
  164.     }
  165.  
  166.     // set state
  167.     ClearState();
  168.     Moving = true;
  169.     CurLeader = Leader;
  170.  
  171.     if ( Leader == "")
  172.     {
  173.       // we are leader. go directly to destination
  174.       SetOrder_MoveTo(
  175.         DestinationPoint,
  176.         CruiserSpeed);
  177.     }
  178.     else
  179.     {
  180.       // leader found. follow him
  181.       SetOrder_Follow(
  182.         Leader, // follow leader
  183.         AutocadDistanceMin,
  184.         AutocadDistanceOptimum,
  185.         AutocadDistanceOvertake,
  186.         CruiserSpeed,
  187.         OvertakeSpeed);
  188.     };
  189.   }
  190.  
  191.   void GiveOrder_RunToTarget()
  192.   {
  193.     //Core_LogMessage("" + Core_GetIdentificator() + ": order: run to target");
  194.  
  195.     string Leader = GetCommander("Convoy_Rank"); // find leader that we should followed by
  196.     if ( Run == true
  197.       && Leader == CurLeader)
  198.     {
  199.       // nothing changed
  200.       return;
  201.     }
  202.  
  203.     // set state
  204.     ClearState();
  205.     Run = true;
  206.  
  207.     CurLeader = Leader;
  208.  
  209.     if ( Leader == "")
  210.     {
  211.       // we are leader. go directly to destination
  212.       SetOrder_MoveTo(
  213.         DestinationPoint,
  214.         RunSpeed);
  215.     }
  216.     else
  217.     {
  218.       // leader found. follow him
  219.       SetOrder_Follow(
  220.         Leader, // follow leader
  221.         AutocadDistanceMin,
  222.         AutocadDistanceOptimum,
  223.         AutocadDistanceOvertake,
  224.         RunSpeed,
  225.         OvertakeSpeed);
  226.     };
  227.   }
  228.  
  229.   void GiveOrder_Disperse()
  230.   {
  231.     //Core_LogMessage("" + Core_GetIdentificator() + ": order: disperce");
  232.  
  233.     // set state
  234.     ClearState();
  235.     Ambushed = true;
  236.  
  237.     SetOrder_StopNow();
  238.  
  239. /*
  240.     string Leader = GetCommander("Convoy_Rank"); // find leader that we should followed by
  241.         if ( Leader == "")
  242.         {
  243.             SetOrder_StopNow();
  244.         }
  245. */
  246.  
  247. /*
  248.         // move to random point
  249.         SetOrder_MoveTo(
  250.             GetNowPosition() + vector( rand(DisperceRadius), rand(DisperceRadius), 0.0),
  251.             OvertakeSpeed);
  252. */
  253.   }
  254.  
  255.  
  256.   //
  257.   // events
  258.  
  259.   void OnToDamage(
  260.     float   _DamageRate,
  261.     string  _TargetId,
  262.     string  _SourceType,
  263.     matrix  _SourcePlace)
  264.   {
  265.     Core_LogMessage("" + Core_GetIdentificator() + ": OnToDamage");
  266.  
  267.     //string EnemyID = GetTargetedEnemy();
  268.  
  269.     // report ambush
  270.     Core_BroadcastEvent("OnAmbush");
  271.   }
  272.  
  273.   void OnEnemyTargeted()
  274.   {
  275.   //#TMP: do not look for enemies
  276.   /*
  277.     //Core_LogMessage("" + Core_GetIdentificator() + ": OnEnemyTargeted");
  278.  
  279.     //string EnemyID = GetTargetedEnemy();
  280.  
  281.     // report ambush
  282.     Core_BroadcastEvent("OnAmbush");
  283.     */
  284.   }
  285.  
  286.   void OnNoEnemy()
  287.   {
  288.     //Core_LogMessage("" + Core_GetIdentificator() + ": OnNoEnemy");
  289.  
  290.     if ( Run == true)
  291.       return;
  292.  
  293.     if ( Ambushed
  294.       && GetCommander("Convoy_Rank") == "")
  295.     {
  296.       // end ambush when commander see no enemy on radar
  297.       Core_BroadcastEvent("OnEndAmbush");
  298.     }
  299.   }
  300.  
  301.   void OnLeaderLost( string _LeaderID)
  302.   {
  303.     if ( Moving)
  304.     {
  305.       GiveOrder_MoveToTarget();
  306.     }
  307.  
  308.     if ( Run)
  309.     {
  310.       GiveOrder_RunToTarget();
  311.     }
  312.   }
  313.  
  314.   void OnUpdate()
  315.   {
  316.     /*
  317.         Core_LogMessage("" + Core_GetIdentificator() + ": OnUpdate");
  318.  
  319.         if ( Retreat == true)// || Run == true)
  320.             return;
  321.  
  322.     Core_LogMessage("" + Core_GetIdentificator() + ": OnUpdate: state passed");
  323.      */
  324.  
  325.     if ( GetGroupObjectsNum("Guard_Rank") == 0) // no guardians left
  326.     {
  327.       GiveOrder_RunToTarget();
  328.  
  329.       return;
  330.     };
  331.  
  332.     if ( Ambushed
  333.       && GetCommander("Convoy_Rank") == "" // we are commander in group
  334.       && GetTargetedEnemy() == "")                 // and cannot see enemy in radar
  335.     {
  336.       // end ambush when commander see no enemy on radar
  337.       Core_BroadcastEvent("OnEndAmbush");
  338.     }
  339.   }
  340.  
  341.   void OnAmbush()
  342.   {
  343.     if ( Run == true)
  344.       return;
  345.  
  346.     if ( ! Ambushed)
  347.     {
  348.       //Core_LogMessage("--- Ambush!!!");
  349.       if ( GetGroupObjectsNum("Guard_Rank") > 0)
  350.       {
  351.         GiveOrder_Disperse();
  352.       }
  353.     }
  354.   }
  355.  
  356.   void OnEndAmbush()
  357.   {
  358.     if ( Run == true)
  359.       return ;
  360.  
  361.     //Core_LogMessage("=== EndAmbush!!!");
  362.     GiveOrder_MoveToTarget();
  363.   }
  364. };
  365.  
  366. class CConvoyMission_SovietTank_ConvoyGuard extends CConvoyMission_SovietTruck_ConvoyTransport
  367. {
  368.   //
  369.   // additional state for guardians
  370.  
  371.   boolean  Defend = false; // true when object is defending convoy
  372.  
  373.   void ClearState()
  374.   {
  375.     Moving    = false;
  376.     Ambushed  = false;
  377.     Run       = false;
  378.     Defend    = false;
  379.     CurLeader = "";
  380.     IsLeader  = false;
  381.   }
  382.  
  383.   //
  384.   // events
  385.  
  386.   void OnAmbush()
  387.   {
  388.     if ( ! Ambushed)
  389.     {
  390.       //Core_LogMessage("+++ Ambush!!!");
  391.       GiveOrder_AttackEnemy();
  392.     }
  393.   }
  394.  
  395.   void GiveOrder_AttackEnemy()
  396.   {
  397.     //Core_LogMessage("" + Core_GetIdentificator() + ": order: line formation");
  398.  
  399.     SetFireStyle_Nearest();
  400.  
  401.     // set state
  402.     ClearState();
  403.     Defend   = true;
  404.     Ambushed = true;
  405.  
  406.     string NearestEnemy = GetTargetedEnemy();
  407.  
  408.     if ( NearestEnemy == "")
  409.       NearestEnemy = GetNearestEnemyUnit_Ranged(1000.0);
  410.  
  411.     if ( NearestEnemy != "")
  412.     {
  413.       SetAttackStyle_DirectMove( true);
  414.       SetOrder_Attack( NearestEnemy, 30.0, 120.0, 30.0);
  415.       SetFireStyle_Enemy( NearestEnemy);
  416.     };
  417.   };
  418. };
  419.  
  420.  
  421. //
  422. // *** Ambushes
  423. //
  424.  
  425. class CConvoyMission_NaziTank_Ambusher extends CBaseAITask_BaseTask
  426. {
  427.   //
  428.   // start up initialization
  429.  
  430.   void Init()
  431.   {
  432.     // give start order
  433.     SetFireStyle_NoFire();
  434.   }
  435.  
  436.   void OnEnemyTargeted()
  437.   {
  438.     string EnemyID = GetTargetedEnemy();
  439.     SetFireStyle_Enemy( EnemyID);
  440.   }
  441.  
  442.   void OnOrderedEnemyKilled()
  443.   {
  444.     string EnemyID = GetTargetedEnemy();
  445.     if ( EnemyID != "")
  446.     {
  447.       SetFireStyle_Enemy( EnemyID);
  448.     }
  449.     else
  450.     {
  451.       SetFireStyle_Nearest();
  452.     }
  453.   }
  454. }
  455.  
  456. class CConvoyMission_NaziTank_Attacker extends CBaseAITask_BaseTask
  457. {
  458.   //
  459.   // start up initialization
  460.  
  461.   void Init()
  462.   {
  463.     // give start order
  464.     SetFireStyle_NoFire();
  465.   }
  466.  
  467.   void OnEnemyTargeted()
  468.   {
  469.     string EnemyID = GetTargetedEnemy();
  470.     SetOrder_Attack( EnemyID, 100.0, 150.0, 12.0);
  471.     SetFireStyle_Enemy( EnemyID);
  472.   }
  473.  
  474.   void OnOrderedEnemyKilled()
  475.   {
  476.     string EnemyID = GetTargetedEnemy();
  477.     if ( EnemyID != "")
  478.     {
  479.       SetOrder_Attack( EnemyID, 100.0, 150.0, 12.0);
  480.       SetFireStyle_Enemy( EnemyID);
  481.     }
  482.     else
  483.     {
  484.       SetFireStyle_Nearest();
  485.     }
  486.   }
  487. }
  488.  
  489. class CConvoyMission_NaziTank_TransportKiller extends CBaseAITask_BaseTask
  490. {
  491.   //
  492.   // current state
  493.  
  494.   boolean AttackTruck = false;
  495.  
  496.  
  497.   //
  498.   // start up initialization
  499.  
  500.   void Init()
  501.   {
  502.     // give start order
  503.     SetFireStyle_NoFire();
  504.     SetRadarRestrictions("Truck"); // attack only trucks
  505.   }
  506.  
  507.  
  508.   //
  509.   // events
  510.  
  511.   void OnToDamage(
  512.     float   _DamageRate,
  513.     string  _TargetId,
  514.     string  _SourceType,
  515.     matrix  _SourcePlace)
  516.   {
  517.     SetRadarRestrictions(); // attack everybody
  518.     SetFireStyle_Nearest();
  519.   }
  520.  
  521.   void OnEnemyTargeted()
  522.   {
  523.     string EnemyID = GetTargetedEnemy();
  524.     SetOrder_Attack( EnemyID, 100.0, 150.0, 12.0);
  525.     SetFireStyle_Enemy( EnemyID);
  526.     AttackTruck = true;
  527.   }
  528.  
  529.   void OnOrderedEnemyKilled()
  530.   {
  531.     string EnemyID = GetTargetedEnemy();
  532.     if ( EnemyID != "")
  533.     {
  534.       SetOrder_Attack( EnemyID, 100.0, 150.0, 12.0);
  535.       SetFireStyle_Enemy( EnemyID);
  536.       AttackTruck = true;
  537.     }
  538.     else
  539.     {
  540.       SetFireStyle_Nearest();
  541.     }
  542.   }
  543. }
  544.  
  545.  
  546. //
  547. // *** special attackers
  548. //
  549.  
  550. class CConvoyMission_NaziTank_BackAttacker_1 extends CBaseAITask_BaseTask
  551. {
  552.   //
  553.   // current state
  554.  
  555.   boolean  Attacking = false;
  556.  
  557.  
  558.   //
  559.   // start up initialization
  560.  
  561.   void Init()
  562.   {
  563.     // give start order
  564.     SetFireStyle_NoFire();
  565.   }
  566.  
  567.   void OnAttackConvoy_1()
  568.   {
  569.     if ( !Attacking)
  570.     {
  571.       Core_LogMessage("" + Core_GetIdentificator() + ": order: Attack Convoy");
  572.  
  573.       string EnemyID = GetLastSlave("Convoy_Rank");
  574.       SetOrder_Attack( EnemyID, 100.0, 150.0, 55.0);
  575.       SetFireStyle_Enemy( EnemyID);
  576.  
  577.       Attacking = true;
  578.     };
  579.   }
  580.  
  581.   void OnOrderedEnemyKilled()
  582.   {
  583.     Core_LogMessage("" + Core_GetIdentificator() + ": order: ReAttack Convoy");
  584.  
  585.     string EnemyID = GetLastSlave("Convoy_Rank");
  586.     if ( EnemyID != "")
  587.     {
  588.       SetOrder_Attack( EnemyID, 100.0, 150.0, 55.0);
  589.       SetFireStyle_Enemy( EnemyID);
  590.     }
  591.     else
  592.     {
  593.       SetFireStyle_Nearest();
  594.     }
  595.   }
  596. }
  597.  
  598. class CConvoyMission_NaziTank_BackAttacker_2 extends CBaseAITask_BaseTask
  599. {
  600.   //
  601.   // current state
  602.  
  603.   boolean  Attacking = false;
  604.  
  605.  
  606.   //
  607.   // start up initialization
  608.  
  609.   void Init()
  610.   {
  611.     // give start order
  612.     SetFireStyle_NoFire();
  613.   }
  614.  
  615.   void OnAttackConvoy_2()
  616.   {
  617.     if ( !Attacking)
  618.     {
  619.       Core_LogMessage("" + Core_GetIdentificator() + ": order: Attack Convoy");
  620.  
  621.       string EnemyID = GetLastSlave("Convoy_Rank");
  622.       SetOrder_Attack( EnemyID, 100.0, 150.0, 55.0);
  623.       SetFireStyle_Enemy( EnemyID);
  624.  
  625.       Attacking = true;
  626.     }
  627.   }
  628.  
  629.   void OnOrderedEnemyKilled()
  630.   {
  631.     Core_LogMessage("" + Core_GetIdentificator() + ": order: ReAttack Convoy");
  632.  
  633.     string EnemyID = GetLastSlave("Convoy_Rank");
  634.     if ( EnemyID != "")
  635.     {
  636.       SetOrder_Attack( EnemyID, 100.0, 150.0, 55.0);
  637.       SetFireStyle_Enemy( EnemyID);
  638.     }
  639.     else
  640.     {
  641.       SetFireStyle_Nearest();
  642.     }
  643.   }
  644. }
  645.  
  646. class NaziPatrol_A extends CBaseAITask_Patrol, CNavPointUser
  647. {
  648. //  void Init()
  649. //  {
  650. //  }
  651.   array GetPatrolTrip()
  652.   {
  653.     return array (GetNavPoint("NavPoint_Ambush_2"),
  654.                   GetNavPoint("NavPoint_Ambush_1"));
  655.   }
  656.   float GetTripSpeed()
  657.   {
  658.     return 26;
  659.   }
  660. }
  661.  
  662. class NaziPatrol_B extends CBaseAITask_Patrol, CNavPointUser
  663. {
  664. //  void Init()
  665. //  {
  666. //  }
  667.   array GetPatrolTrip()
  668.   {
  669.     return array (vector(5377.0, 9814.0, 0.0),
  670.                   GetNavPoint("NavPoint_Ambush_2"));
  671.   }
  672.   float GetTripSpeed()
  673.   {
  674.     return 26;
  675.   }
  676. }
  677. //==================================================================
  678. class AttackPlatoon_A extends CBaseAITask_BaseTask, CNavPointUser
  679. {
  680.   int StartTime = 0;
  681.   int CurrentTime = 0;
  682.   boolean Started = false;
  683.   final int TimeToStart = 220000;
  684.  
  685.   void Attack_A()
  686.    {
  687.      StartTime = GetGameTime();
  688.    }
  689.  
  690.   void  OnUpdate()
  691.    {
  692.      CurrentTime = GetGameTime();
  693.      if( CurrentTime >= (StartTime+TimeToStart) && !Started && StartTime > 0 )
  694.        {
  695.          Started = true;
  696.          MoveToPointA();
  697. //       DoAttack();
  698. //         Core_LogMessage("Attack A has started. Time after convoy is "+(CurrentTime-StartTime));
  699.        }
  700.    }
  701.  
  702.   void MoveToPointA()
  703.    {
  704.      SetOrder_MoveTo( GetNavPoint("NavPoint_PatrolA"), 26 );
  705.    }
  706.  
  707.   void AttackTarget_A()
  708.     {
  709.       DoAttack();
  710.     }
  711.  
  712.   void DoAttack()
  713.   {
  714.     string NearestEnemy = GetTargetedEnemy();
  715.  
  716.     if ( NearestEnemy == "")
  717.     {
  718.       NearestEnemy = GetNearestEnemyUnit();
  719.     };
  720.  
  721.     SetOrder_Attack( NearestEnemy, 100.0, 150.0, 27.0);
  722.     SetFireStyle_Enemy( NearestEnemy );
  723.  
  724.   }
  725.  
  726.   void OnOrderedEnemyKilled()
  727.   {
  728.     SetFireStyle_Nearest();
  729.     DoAttack();
  730.   }
  731. }
  732. //------------------------------------------------------------------
  733. class AttackPlatoon_B extends CBaseAITask_BaseTask, CNavPointUser
  734. {
  735.   int StartTime = 0;
  736.   int CurrentTime = 0;
  737.   boolean Started = false;
  738.   final int TimeToStart = 130000;
  739.  
  740.   void Attack_B()
  741.    {
  742.      StartTime = GetGameTime();
  743.    }
  744.  
  745.   void  OnUpdate()
  746.    {
  747.      CurrentTime = GetGameTime();
  748.      if( CurrentTime >= (StartTime+TimeToStart) && !Started && StartTime > 0 )
  749.        {
  750.          Started = true;
  751.          MoveToPointB();
  752. //         DoAttack();
  753.        }
  754.    }
  755.  
  756.   void MoveToPointB()
  757.    {
  758.      SetOrder_MoveTo( GetNavPoint("NavPoint_PatrolB"), 26 );
  759.    }
  760.  
  761.   void AttackTarget_B()
  762.     {
  763.       DoAttack();
  764.     }
  765.  
  766.   void DoAttack()
  767.   {
  768.     string NearestEnemy = GetTargetedEnemy();
  769.  
  770.     if ( NearestEnemy == "")
  771.     {
  772.       NearestEnemy = GetNearestEnemyUnit();
  773.     };
  774.  
  775.     SetOrder_Attack( NearestEnemy, 100.0, 150.0, 27.0);
  776.     SetFireStyle_Enemy( NearestEnemy );
  777.  
  778.   }
  779.  
  780.   void OnOrderedEnemyKilled()
  781.   {
  782.     SetFireStyle_Nearest();
  783.     DoAttack();
  784.   }
  785. }
  786.  
  787.  
  788.